"""
关键词话术管理器，用于从配置路径获取关键词话术
"""
import os
import random
import re
from typing import List, Optional, Tuple, Dict
from app.utils.logger import Logger


class KeywordSpeechManager:
    """
    关键词话术管理器，负责从配置路径获取关键词话术
    """
    
    def __init__(self, config_path: str):
        """
        初始化关键词话术管理器
        
        @param config_path: 配置路径
        """
        self.config_path = config_path
        self.keyword_speech_dir = os.path.join(config_path, "话术管理", "关键词话术")
        
        # 获取日志记录器
        self.logger = Logger.get_logger("keyword_speech_manager")
        
        # 关键词映射表，格式: {关键词: [文件名, ...]}
        self._keyword_map: Dict[str, List[str]] = {}
        
        # 话术内容缓存，格式: {文件名: 文件内容}
        self._speeches: Dict[str, str] = {}
        
        self.logger.info(f"关键词话术管理器初始化，配置路径: {config_path}")
        self.logger.info(f"关键词话术目录: {self.keyword_speech_dir}")
        
        # 加载关键词话术
        self._load_keyword_speeches()
        
        self.logger.info(f"关键词话术管理器初始化完成，已加载 {len(self._speeches)} 个话术文件，{len(self._keyword_map)} 个关键词")
    
    def _load_keyword_speeches(self) -> None:
        """
        加载关键词话术
        """
        try:
            # 检查关键词话术目录是否存在
            if not os.path.exists(self.keyword_speech_dir):
                os.makedirs(self.keyword_speech_dir, exist_ok=True)
                self.logger.warning(f"关键词话术目录不存在，已创建: {self.keyword_speech_dir}")
                
                # 创建示例关键词话术文件
                try:
                    example_file_path = os.path.join(self.keyword_speech_dir, "已拍@拍了@拍好了.txt")
                    with open(example_file_path, 'w', encoding='utf-8') as f:
                        f.write("已收到您的拍摄，感谢您的支持！\n")
                        f.write("已为您记录拍摄信息，稍后为您处理～\n")
                        f.write("好的{用户名}，已记录您的拍摄，请耐心等待哦！\n")
                    
                    self.logger.info(f"已创建示例关键词话术文件: {example_file_path}")
                    
                    # 再创建一个问候关键词文件
                    greeting_file_path = os.path.join(self.keyword_speech_dir, "你好@问候@大家好.txt")
                    with open(greeting_file_path, 'w', encoding='utf-8') as f:
                        f.write("你好{用户名}，欢迎来到直播间！\n")
                        f.write("大家好，感谢大家的支持！\n")
                        f.write("欢迎{用户名}，很高兴看到您！\n")
                    
                    self.logger.info(f"已创建示例问候关键词话术文件: {greeting_file_path}")
                except Exception as e:
                    self.logger.error(f"创建示例关键词话术文件失败: {str(e)}")
                
                # 由于刚创建目录，直接返回，避免后续代码尝试读取不存在的文件
                return
            
            self.logger.info(f"开始加载关键词话术，目录: {self.keyword_speech_dir}")
            
            # 清空缓存
            self._keyword_map.clear()
            self._speeches.clear()
            
            # 获取关键词话术目录中的所有文件
            files = [f for f in os.listdir(self.keyword_speech_dir) if os.path.isfile(os.path.join(self.keyword_speech_dir, f))]
            
            # 遍历文件
            file_count = len(files)
            for file_name in files:
                file_path = os.path.join(self.keyword_speech_dir, file_name)
                
                self.logger.debug(f"发现文件: {file_name}")
                
                try:
                    # 解析文件名中的关键词
                    keywords = self._extract_keywords_from_filename(file_name)
                    
                    # 如果没有关键词，跳过
                    if not keywords:
                        self.logger.warning(f"文件名中未找到关键词: {file_name}")
                        continue
                    
                    # 读取文件内容
                    with open(file_path, "r", encoding="utf-8") as f:
                        content = f.read().strip()
                        
                        # 如果内容不为空，添加到缓存
                        if content:
                            self._speeches[file_name] = content
                            
                            # 将每个关键词与文件名建立映射
                            for keyword in keywords:
                                if keyword not in self._keyword_map:
                                    self._keyword_map[keyword] = []
                                
                                # 添加到映射表
                                if file_name not in self._keyword_map[keyword]:
                                    self._keyword_map[keyword].append(file_name)
                                    
                            self.logger.debug(f"已加载关键词话术文件: {file_name}, 关键词: {', '.join(keywords)}")
                        else:
                            self.logger.warning(f"文件内容为空: {file_path}")
                except Exception as e:
                    self.logger.error(f"处理文件失败: {file_path}, 错误: {str(e)}")
            
            self.logger.info(f"关键词话术加载完成，共扫描 {file_count} 个文件，加载 {len(self._speeches)} 个话术文件")
            self.logger.info(f"关键词总数: {len(self._keyword_map)}")
            
            # 打印所有关键词
            if self._keyword_map:
                self.logger.debug(f"已加载的关键词: {', '.join(self._keyword_map.keys())}")
        except Exception as e:
            self.logger.error(f"加载关键词话术失败: {str(e)}")
    
    def _extract_keywords_from_filename(self, file_name: str) -> List[str]:
        """
        从文件名中提取关键词
        
        @param file_name: 文件名
        @return: 关键词列表
        """
        try:
            # 去除扩展名
            name_without_ext = os.path.splitext(file_name)[0]
            
            # 使用@分隔符拆分关键词
            keywords = [kw.strip() for kw in name_without_ext.split('@') if kw.strip()]
            
            return keywords
        except Exception as e:
            self.logger.error(f"从文件名提取关键词失败: {file_name}, 错误: {str(e)}")
            return []
    
    def find_matching_keyword(self, content: str) -> Tuple[Optional[str], Optional[str]]:
        """
        查找内容中匹配的关键词
        
        @param content: 内容文本
        @return: 元组 (匹配的关键词, 对应的文件名)，如果没有匹配则返回 (None, None)
        """
        if not content or not self._keyword_map:
            return (None, None)
        
        try:
            # 遍历所有关键词
            for keyword, files in self._keyword_map.items():
                if keyword in content:
                    # 找到匹配的关键词，返回第一个对应的文件
                    if files:
                        return (keyword, files[0])
            
            return (None, None)
        except Exception as e:
            self.logger.error(f"查找匹配关键词失败: {str(e)}")
            return (None, None)
    
    def get_random_speech(self, file_name: str) -> Optional[str]:
        """
        从指定文件中获取随机一行话术
        
        @param file_name: 文件名
        @return: 随机话术内容，如果文件不存在则返回None
        """
        if not file_name or file_name not in self._speeches:
            return None
            
        try:
            content = self._speeches[file_name]
            lines = [line.strip() for line in content.split('\n') if line.strip()]
            
            if not lines:
                return None
                
            # 随机选择一行
            speech = random.choice(lines)
            self.logger.debug(f"从文件 {file_name} 获取随机话术: {speech[:30]}...")
            
            return speech
        except Exception as e:
            self.logger.error(f"获取随机话术失败: {str(e)}")
            return None
    
    def reload(self) -> None:
        """
        重新加载关键词话术
        """
        self.logger.info("重新加载关键词话术")
        self._load_keyword_speeches() 